<?xml version='1.0' encoding='iso-8859-1'?>
<!doctype html public '-//W3C//DTD XHTML 1.0 Strict//EN' 'http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd'>
<html xmlns='http://www.w3c.org/1999/xhtml' lang='en-us'>
	<head>
		<title>
			ruledump.c
			</title>
		<meta http-equiv='content-type' content='text/html;iso-8859-1'/>
		<meta name='generator' content='motley-tools 1.9.4 13:40:33 Feb 18 2015'/>
		<meta name='author' content='cmaier@cmassoc.net'/>
		<meta name='robots' content='noindex,nofollow'/>
		<link href='toolkit.css' rel='stylesheet' type='text/css'/>
		</head>
	<body>
		<div class='headerlink'>
			[<a href='RNDPasswords.c.html' title=' RNDPasswords.c '>PREV</a>]
			[<a href='toolkit.html' title=' Index '>HOME</a>]
			[<a href='rules.c.html' title=' rules.c '>NEXT</a>]
			</div>
<pre>
/*====================================================================*
 *
 *   Copyright (c) 2013 Qualcomm Atheros, Inc.
 *
 *   All rights reserved.
 *
 *   Redistribution and use in source and binary forms, with or 
 *   without modification, are permitted (subject to the limitations 
 *   in the disclaimer below) provided that the following conditions 
 *   are met:
 *
 *   * Redistributions of source code must retain the above copyright 
 *     notice, this list of conditions and the following disclaimer.
 *
 *   * Redistributions in binary form must reproduce the above 
 *     copyright notice, this list of conditions and the following 
 *     disclaimer in the documentation and/or other materials 
 *     provided with the distribution.
 *
 *   * Neither the name of Qualcomm Atheros nor the names of 
 *     its contributors may be used to endorse or promote products 
 *     derived from this software without specific prior written 
 *     permission.
 *
 *   NO EXPRESS OR IMPLIED LICENSES TO ANY PARTY'S PATENT RIGHTS ARE 
 *   GRANTED BY THIS LICENSE. THIS SOFTWARE IS PROVIDED BY THE 
 *   COPYRIGHT HOLDERS AND CONTRIBUTORS &quot;AS IS&quot; AND ANY EXPRESS OR 
 *   IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED 
 *   WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR 
 *   PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER 
 *   OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 
 *   SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT 
 *   NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; 
 *   LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 
 *   HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN 
 *   CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE 
 *   OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS 
 *   SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.  
 *
 *--------------------------------------------------------------------*/

/*====================================================================*
 *
 *   void ruledump (struct rule * rule, FILE * fp);
 *
 *
 *--------------------------------------------------------------------*/

#ifndef RULEDUMP_SOURCE
#define RULEDUMP_SOURCE

#include &lt;stdio.h&gt;

#include &quot;../tools/memory.h&quot;
#include &quot;../plc/rules.h&quot;

/*====================================================================*
 *
 *   cspec_dump (struct cspec * cspec);
 *
 *
 *--------------------------------------------------------------------*/

void cspec_dump (struct cspec * cspec)

{
	printf (&quot;cspec-&gt;CSPEC_VERSION=%d\n&quot;, LE16TOH (cspec-&gt;CSPEC_VERSION));
	printf (&quot;cspec-&gt;VLAN_TAG=%d\n&quot;, LE16TOH (cspec-&gt;VLAN_TAG));
	return;
}

/*====================================================================*
 *
 *   MMEClassifierDump (struct MMEClassifier * classifier);
 *
 *
 *--------------------------------------------------------------------*/

void MMEClassifierDump (struct MMEClassifier * classifier)

{
	char string [48];
	printf (&quot;classifier-&gt;CR_PID=0x%02X\n&quot;, (unsigned)(classifier-&gt;CR_PID));
	printf (&quot;classifier-&gt;CR_OPERAND=0x%02X\n&quot;, classifier-&gt;CR_OPERAND);
	hexdecode (classifier-&gt;CR_VALUE, sizeof (classifier-&gt;CR_VALUE), string, sizeof (string));
	printf (&quot;classifier-&gt;CR_VALUE=%s\n&quot;, string);
	return;
}

/*====================================================================*
 *
 *   PIBClassifierDump (struct PIBClassifier * classifier);
 *
 *
 *--------------------------------------------------------------------*/

void PIBClassifierDump (struct PIBClassifier * classifier)

{
	char string [48];
	printf (&quot;classifier-&gt;CR_PID=0x%08X\n&quot;, LE32TOH (classifier-&gt;CR_PID));
	printf (&quot;classifier-&gt;CR_OPERAND=0x%08X\n&quot;, LE32TOH (classifier-&gt;CR_OPERAND));
	hexdecode (classifier-&gt;CR_VALUE, sizeof (classifier-&gt;CR_VALUE), string, sizeof (string));
	printf (&quot;classifier-&gt;CR_VALUE=%s\n&quot;, string);
	return;
}

/*====================================================================*
 *
 *   MMERuleDump (struct MMERule * rule);
 *
 *
 *--------------------------------------------------------------------*/

void MMERuleDump (struct MMERule * rule)

{
	unsigned count;
	printf (&quot;rule-&gt;MCONTROL=%d\n&quot;, rule-&gt;MCONTROL);
	printf (&quot;rule-&gt;MVOLATILITY=%d\n&quot;, rule-&gt;MVOLATILITY);
	printf (&quot;rule-&gt;MACTION=%d\n&quot;, rule-&gt;MACTION);
	printf (&quot;rule-&gt;MOPERAND=%d\n&quot;, rule-&gt;MOPERAND);
	printf (&quot;rule-&gt;NUM_CLASSIFIERS=%d\n&quot;, rule-&gt;NUM_CLASSIFIERS);
	for (count = 0; count &lt; rule-&gt;NUM_CLASSIFIERS; count++)
	{
		MMEClassifierDump (&amp;rule-&gt;CLASSIFIER [count]);
	}
	cspec_dump (&amp;rule-&gt;cspec);
	printf (&quot;\n&quot;);
	return;
}

/*====================================================================*
 *
 *   PIBRuleDump (struct PIBRule * rule);
 *
 *
 *--------------------------------------------------------------------*/

void PIBRuleDump (struct PIBRule * rule)

{
	unsigned count;
	printf (&quot;rule-&gt;MCONTROL=%d\n&quot;, rule-&gt;MCONTROL);
	printf (&quot;rule-&gt;MVOLATILITY=%d\n&quot;, rule-&gt;MVOLATILITY);
	printf (&quot;rule-&gt;MACTION=%d\n&quot;, rule-&gt;MACTION);
	printf (&quot;rule-&gt;MOPERAND=%d\n&quot;, rule-&gt;MOPERAND);
	printf (&quot;rule-&gt;NUM_CLASSIFIERS=%d\n&quot;, LE32TOH (rule-&gt;NUM_CLASSIFIERS));
	for (count = 0; count &lt; LE32TOH (rule-&gt;NUM_CLASSIFIERS); count++)
	{
		PIBClassifierDump (&amp;rule-&gt;CLASSIFIER [count]);
	}
	cspec_dump (&amp;rule-&gt;cspec);
	printf (&quot;\n&quot;);
	return;
}

/*====================================================================*
 *
 *   classifier_priority_map_dump (struct classifier_priority_map * classifier_priority_map);
 *
 *
 *--------------------------------------------------------------------*/

void classifier_priority_map_dump (struct classifier_priority_map * classifier_priority_map)

{
	printf (&quot;classifier_priority_map-&gt;Priority=%d\n&quot;, LE32TOH (classifier_priority_map-&gt;Priority));
	PIBClassifierDump (&amp;classifier_priority_map-&gt;CLASSIFIER);
	return;
}

/*====================================================================*
 *
 *   auto_connection_dump (struct auto_connection * auto_connection);
 *
 *
 *--------------------------------------------------------------------*/

void auto_connection_dump (struct auto_connection * auto_connection)

{
	unsigned count;
	printf (&quot;auto_connection-&gt;MACTION=%d\n&quot;, auto_connection-&gt;MACTION);
	printf (&quot;auto_connection-&gt;MOPERAND=%d\n&quot;, auto_connection-&gt;MOPERAND);
	printf (&quot;auto_connection-&gt;NUM_CLASSIFIERS=%d\n&quot;, LE16TOH (auto_connection-&gt;NUM_CLASSIFIERS));
	for (count = 0; count &lt; LE16TOH (auto_connection-&gt;NUM_CLASSIFIERS); count++)
	{
		PIBClassifierDump (&amp;auto_connection-&gt;CLASSIFIER [count]);
	}
	cspec_dump (&amp;auto_connection-&gt;cspec);
	return;
}

/*====================================================================*
 *
 *   PIBClassifiersDump (struct PIBClassifiers * classifiers);
 *
 *
 *--------------------------------------------------------------------*/

void PIBClassifiersDump (struct PIBClassifiers * classifiers)

{
	unsigned count;
	printf (&quot;classifiers-&gt;priority_count=%d\n&quot;, LE32TOH (classifiers-&gt;priority_count));
	printf (&quot;classifiers-&gt;autoconn_count=%d\n&quot;, LE32TOH (classifiers-&gt;autoconn_count));
	printf (&quot;\n&quot;);
	printf (&quot;-------- PRIORITY MAPS --------\n\n&quot;);
	for (count = 0; count &lt; LE32TOH (classifiers-&gt;priority_count); count++)
	{
		classifier_priority_map_dump (&amp;classifiers-&gt;classifier_priority_map [count]);
	}
	printf (&quot;\n&quot;);
	printf (&quot;-------- AUTO CONNECTIONS --------\n\n&quot;);
	for (count = 0; count &lt; LE32TOH (classifiers-&gt;autoconn_count); count++)
	{
		auto_connection_dump (&amp;classifiers-&gt;auto_connection [count]);
	}
	printf (&quot;\n&quot;);
	return;
}

/*====================================================================*
 *
 *--------------------------------------------------------------------*/

#endif


</pre>
		<div class='footerlink'>
			[<a href='RNDPasswords.c.html' title=' RNDPasswords.c '>PREV</a>]
			[<a href='toolkit.html' title=' Index '>HOME</a>]
			[<a href='rules.c.html' title=' rules.c '>NEXT</a>]
			</div>
		</body>
	</html>
